home *** CD-ROM | disk | FTP | other *** search
/ Hot Super Models / Hot Super Models.iso / unix / x11 / xv200.tar / xv-2.00 / unsupt / vicar < prev    next >
Text File  |  1992-01-01  |  78KB  |  2,148 lines
  1. (Message /usr/users/bradley/Mail/inbox:27)
  2. Return-Path: datri@lovecraft.convex.com
  3. Received-Date: Tue, 29 Oct 91 15:06:28 EST
  4. Received: from convex.convex.com by central.cis.upenn.edu
  5.     id AA26939; Tue, 29 Oct 91 15:06:07 -0500
  6. Posted-Date: Tue, 29 Oct 1991 14:03:52 -0600 (CST)
  7. Received: from lovecraft.convex.com by convex.convex.com (5.61/1.35)
  8.     id AA23755; Tue, 29 Oct 91 14:03:55 -0600
  9. Received: by lovecraft.convex.com (4.1/SMI-4.1)
  10.     id AA26110; Tue, 29 Oct 91 14:03:53 CST
  11. Received: from Messages.7.15.N.CUILIB.3.45.SNAP.NOT.LINKED.lovecraft.convex.com.sun4.41
  12.           via MS.5.6.lovecraft.convex.com.sun4_41;
  13.           Tue, 29 Oct 1991 14:03:52 -0600 (CST)
  14. Message-Id: <wd3Pucm2e4NhRWUuI=@concave>
  15. Date: Tue, 29 Oct 1991 14:03:52 -0600 (CST)
  16. From: "Anthony A. Datri" <datri@concave.convex.com>
  17. To: bradley@central.cis.upenn.edu
  18. Subject: xv
  19.  
  20. I hear that you're intested in my additions to xv after all.  There's a
  21. tar file of the whole thing on convex.com for anonymous ftp, and here
  22. are the diffs that I think should work.
  23.  
  24. Add a line to the Makefile like
  25.  
  26. # if you don't have strstr, uncomment this
  27. STRSTRF = #-DNOSTRSTR
  28.  
  29.  
  30.  
  31. # This is a shell archive.  Remove anything before this line,
  32. # then unpack it by saving it in a file and typing "sh file".
  33. #
  34. # Wrapped by lovecraft!datri on Tue Oct 29 13:59:32 CST 1991
  35. # Contents:  diff pds.h pdsuncomp.c xvpds.c
  36.  
  37. echo x - diff
  38. sed 's/^@//' > "diff" <<'@//E*O*F diff//'
  39. diff -c pristine/xv.c xv/xv.c
  40. *** pristine/xv.c    Thu Nov 29 12:44:53 1990
  41. --- xv/xv.c    Tue Sep  3 13:50:45 1991
  42. ***************
  43. *** 53,58 ****
  44. --- 53,59 ----
  45.   #define PM      2
  46.   #define PBM     3
  47.   #define XBM     4
  48. + #define PDS    5
  49.   
  50.   static unsigned long rootbg, rootfg;  /* fg/bg for root border */
  51.   static int    waitsec = -1;     /* seconds between pics. -1=wait for event */
  52. ***************
  53. *** 785,791 ****
  54.     else if (magicno[0] == 'P' && magicno[1]>='1' && 
  55.          magicno[1]<='6') filetype = PBM;
  56.   
  57. !   else if (strncmp(magicno,"#define",7)==0) filetype = XBM;
  58.   
  59.     if (filetype == UNKNOWN) {
  60.       SetISTR(ISTR_INFO,"'%s' not in a recognized format.", basename);
  61. --- 786,798 ----
  62.     else if (magicno[0] == 'P' && magicno[1]>='1' && 
  63.          magicno[1]<='6') filetype = PBM;
  64.   
  65. !  /* this doesn't *really* detect the full magic, since the above
  66. !     code only reads 8 bytes */
  67. !   else if (strncmp(magicno,"NJPL1I00",8)==0 ||
  68. !        strncmp(magicno+2,"NJPL1I",6)==0 ||
  69. !        strncmp(magicno,"LBLSIZE=",8)==0) {
  70. !     filetype = PDS;
  71. !   }  else if (strncmp(magicno,"#define",7)==0) filetype = XBM;
  72.   
  73.     if (filetype == UNKNOWN) {
  74.       SetISTR(ISTR_INFO,"'%s' not in a recognized format.", basename);
  75. ***************
  76. *** 800,805 ****
  77. --- 807,813 ----
  78.     case PM:  i = LoadPM (filename,ncols); break;
  79.     case PBM: i = LoadPBM(filename,ncols); break;
  80.     case XBM: i = LoadXBM(filename,ncols); break;
  81. +   case PDS: i = LoadPDS(filename,ncols); break;
  82.     }
  83.     WaitCursor();
  84.   
  85. diff -c pristine/xv.h xv/xv.h
  86. *** pristine/xv.h    Thu Nov 29 12:45:35 1990
  87. --- xv/xv.h    Fri Sep  6 10:37:04 1991
  88. ***************
  89. *** 38,45 ****
  90.   #endif
  91.   
  92.   /* neither IBM AOS 4.3, Convex, nor BSD 4.3 on VAX have <malloc.h> */
  93. ! #if !defined(ibm032) && !defined(__convexc__) && \
  94. !     !(defined(vax) && !defined(ultrix))
  95.   #if defined(hp300) || defined(hp800)
  96.   #include <sys/malloc.h>                /* it's in 'sys' on HPs*/
  97.   #else
  98. --- 38,44 ----
  99.   #endif
  100.   
  101.   /* neither IBM AOS 4.3, Convex, nor BSD 4.3 on VAX have <malloc.h> */
  102. ! #if !defined(ibm032) && !defined(__convexc__) && !(defined(vax) &&
  103. !defined(ultrix))
  104.   #if defined(hp300) || defined(hp800)
  105.   #include <sys/malloc.h>                /* it's in 'sys' on HPs*/
  106.   #else
  107. ***************
  108. *** 558,567 ****
  109.   int LoadXBM(char *, int);
  110.   int WriteXBM(FILE *, byte *, int, int, char *);
  111.   
  112.   
  113. - 
  114. - 
  115. - 
  116.   #else     /* using non-ANSI cc.  Function defs, but no params */
  117.   
  118.   
  119. --- 557,565 ----
  120.   int LoadXBM(char *, int);
  121.   int WriteXBM(FILE *, byte *, int, int, char *);
  122.   
  123. + /**************************** XVPDS.C ***************************/
  124. + int LoadPDS(char *, int);
  125.   
  126.   #else     /* using non-ANSI cc.  Function defs, but no params */
  127.   
  128.   
  129. ***************
  130. *** 632,636 ****
  131. --- 630,636 ----
  132.   /**************************** XVXBM.C ***************************/
  133.   int LoadXBM(), WriteXBM();
  134.   
  135. + /**************************** XVPDS.C ***************************/
  136. + int LoadPDS();
  137.   
  138.   #endif
  139. @//E*O*F diff//
  140. chmod u=rw,g=r,o=r diff
  141.  
  142. echo x - pds.h
  143. sed 's/^@//' > "pds.h" <<'@//E*O*F pds.h//'
  144. #define PDSFIXED    (1)
  145. #define    PDSVARIABLE    (2)
  146. #define PDSTRASH    (-1)
  147. #define VICAR        (3)
  148.  
  149. @//E*O*F pds.h//
  150. chmod u=rw,g=r,o=r pds.h
  151.  
  152. echo x - pdsuncomp.c
  153. sed 's/^@//' > "pdsuncomp.c" <<'@//E*O*F pdsuncomp.c//'
  154. /* datri@convex.com, 4-14-91
  155.    This file is taken almost unchanged from the NASA CD-ROMS of the Voyager
  156.    images.  I can find no copyright anywhere near this code.
  157.    All I've done is added - as a special case for the output
  158.    filename to go to stdout, and made informational messages go to stderr
  159.    instead of stdout, removing some of the silly ones.  I've also corrected
  160.    some of the places where fools assume that VAX and VMS are synonymous */
  161.  
  162. /********************************************************************/
  163. /*  Voyager Image Decompression Program - C Version for PC, VAX,    */
  164. /*  UNIX and Macintosh systems.                                     */
  165. /*                                                                  */
  166. /*  Decompresses images using Kris Becker's subroutine DECOMP.C     */
  167. /*  which is included in this program in a shortened version.       */
  168. /*                                                                  */
  169. /*  Reads a variable length compressed VOYAGER image and outputs a  */
  170. /*  fixed length uncompressed image file in PDS format with         */
  171. /*  labels, image histogram, engineering table and 800 lines of     */
  172. /*  836 bytes (800 samples, 36 engineering bytes); or an 800 by     */
  173. /*  800 array with FITS, VICAR or no labels.  If used on a non-     */
  174. /*  byte-swapped machine the image histogram is un-swapped.         */
  175. /*                                                                  */
  176. /********************************************************************/
  177. /*                                                                  */
  178. /*  Use the following commands to compile and link to produce an    */
  179. /*  executable file:                                                */
  180. /*                                                                  */
  181. /*  On an IBM PC (using Microsoft C Version 5.x)                    */
  182. /*                                                                  */
  183. /*    cl /c cdcomp.c                                                */
  184. /*    link  cdcomp/stack:10000;                                     */
  185. /*                                                                  */
  186. /*  On a VAX:                                                       */
  187. /*                                                                  */
  188. /*    cc   cdcomp                                                   */
  189. /*    $define lnk$library sys$library:vaxcrtl.olb                   */
  190. /*    link cdcomp                                                   */
  191. /*                                                                  */
  192. /*  On a Unix host (Sun, Masscomp)                                  */
  193. /*                                                                  */
  194. /*    cc -o cdcomp cdcomp.c                                         */
  195. /*                                                                  */
  196. /*  On a Macintosh (using Lightspeed C)                             */
  197. /*                                                                  */
  198. /*    link with the following libraries:                            */
  199. /*    stdio, storage, strings, unix and MacTraps, with MacTraps     */
  200. /*    in a separate segment.                                        */
  201. /*                                                                  */
  202. /********************************************************************/
  203. /*                                                                  */
  204. /*  Use the following command to run the program:                   */
  205. /*                                                                  */
  206. /*    CDCOMP [infile] [outfile] [output format]                     */
  207. /*                                                                  */
  208. /*       infile        - name of compressed image file.             */
  209. /*       outfile       - name of uncompressed output file.          */
  210. /*       output format - selected from the following list:          */
  211. /*                                                                  */
  212. /*          1  SFDU/PDS format [DEFAULT].                           */
  213. /*          2  FITS format.                                         */
  214. /*          3  VICAR format.                                        */
  215. /*          4  Unlabelled binary array.                             */
  216. /*                                                                  */
  217. /*  Under VMS you will need to 'install' the program to            */
  218. /*  be able to use command line arguments using the following       */
  219. /*  command:                                                        */
  220. /*                                                                  */
  221. /*  $ vaxdcomp :== $DISKNAME:[DIRECTORY]vaxcomp.exe                 */
  222. /*                                                                  */
  223. /*  where DISKNAME is the disk drive and DIRECTORY is the           */
  224. /*  directory where VAXDCOMP.EXE is stored.                         */
  225. /*                                                                  */
  226. /********************************************************************/
  227. /*                                                                  */
  228. /* LIMS                                                             */
  229. /*  This program has been tested on a VAX 780 (VMS 4.6), SUN        */
  230. /*  Workstation (UNIX 4.2, release 3.4), an IBM PC                  */
  231. /*  (MICROSOFT 5.1 compiler) and Macintosh IIx using Lightspeed C   */
  232. /*  version 3.0.  When converting to other systems, check for       */
  233. /*  portability conflicts.                                          */
  234. /*                                                                  */
  235. /* HIST                                                             */
  236. /*  AUG89 Added code to get command line arguments for filenames    */
  237. /*  and output format; routines to free memory used by the Huffman  */
  238. /*  tree); fixed the SFDU label output length; and modified the     */
  239. /*  I/O routines so that the open for Host type 2 uses binary I/O.  */
  240. /*  JUN89 Fixed READVAR, to get length on 16-bit unswapped hosts.   */
  241. /*  JUL88 C driver to decompress standard Voyager Compressed images */
  242. /*  by Mike Martin 1989/06/10                                       */
  243. /*                                                                  */
  244. /*  Inputs   - Input file to be decompressed.                       */
  245. /*                                                                  */
  246. /*  Outputs  - Output file containing decompressed image.           */
  247. /*                                                                  */
  248. /********************************************************************/
  249.  
  250. #include <stdio.h>
  251.  
  252. #define TRUE                  1
  253. #define FALSE                 0
  254. #define RECORD_BYTES        836
  255.  
  256.                                     /* pc i/o defines               */
  257. #define O_RDONLY         0x0000     /* open for reading only        */
  258. #define O_BINARY         0x8000     /* file mode is binary          */
  259.  
  260.                                     /* vax i/o defines              */
  261. #define RECORD_TYPE      "rfm=fix"  /* VMS fixed length output      */
  262. #define CTX              "ctx=bin"  /* no translation of \n         */
  263. #define FOP          "fop=cif,sup"  /* file processing ops          */
  264.  
  265. typedef struct leaf
  266.   {
  267.    struct leaf *right;
  268.    short int dn;
  269.    struct leaf *left;
  270.   } NODE;
  271.  
  272. /*************************************************************************
  273.  Declare the tree pointer. This pointer will hold the root of the tree
  274.  once the tree is created by the accompanying routine huff_tree.
  275. **************************************************************************/
  276.  
  277.   NODE *tree;
  278.  
  279. /* subroutine definitions                                           */
  280.  
  281. void               pds_labels();
  282. void               fits_labels();
  283. void               vicar_labels();
  284. void               no_labels();
  285. int                check_host();
  286. int                get_files();
  287. long               swap_long();
  288. void               decompress();
  289. void               decmpinit();
  290. void               free_tree();
  291.  
  292. /* global variables                                                 */
  293.  
  294. int                infile,Argc;
  295. FILE               *outfile;
  296. char               inname[80],outname[80];
  297. int                output_format;
  298.  
  299. main(argc,argv)
  300.  
  301. int  argc;
  302. char **argv;
  303.  
  304. {
  305. char          ibuf[2048],obuf[2048];
  306. unsigned char blank=32;
  307. short         host,length,total_bytes,line,i;
  308. long          long_length,hist[511];
  309. int           out_bytes = RECORD_BYTES;
  310. int           count;
  311.  
  312. /*********************************************************************/
  313. /*                                                                   */
  314. /* get host information and input and output files                   */
  315. /*                                                                   */
  316. /*********************************************************************/
  317.  
  318.    Argc=argc;
  319.    strcpy(inname,"   ");
  320.    strcpy(outname,"   ");
  321.    output_format = 0;
  322.  
  323.    if (argc == 1);                     /* prompt user for parameters */
  324.    else if (argc == 2 && (strncmp(argv[1],"help",4) == 0 || 
  325.                           strncmp(argv[1],"HELP",4) == 0 ||
  326.                           strncmp(argv[1],"?",1)    == 0))
  327.      {
  328.       fprintf(stderr,"Voyager Image Decompression Program.  Command line
  329. format:\n\n");
  330.       fprintf(stderr,"CDCOMP [infile] [outfile] [format code]\n");
  331.       fprintf(stderr,"   infile        - name of compressed image file. 
  332.    \n");
  333.       fprintf(stderr,"   outfile       - name of uncompressed output
  334. file.  \n");
  335.       fprintf(stderr,"   output format - selected from the following
  336. list:  \n");   
  337.       fprintf(stderr,"                                                  
  338.    \n");   
  339.       fprintf(stderr,"     1  SFDU/PDS format [DEFAULT].                
  340.    \n");   
  341.       fprintf(stderr,"     2  FITS format.                              
  342.    \n");   
  343.       fprintf(stderr,"     3  VICAR format.                             
  344.    \n");   
  345.       fprintf(stderr,"     4  Unlabelled binary array.                  
  346.  \n\n");   
  347.       exit(1);
  348.      }  
  349.    else 
  350.      {
  351.       strcpy(inname,argv[1]);  
  352.       if (argc >= 3) strcpy(outname,argv[2]); 
  353.       if (argc == 3) output_format = 1;
  354.       if (argc == 4) sscanf(argv[3],"%d",&output_format); 
  355.      }
  356.    host = check_host();
  357.    host = get_files(host); /* may change host if VAX */
  358.  
  359. /*********************************************************************/
  360. /*                                                                   */
  361. /* read and edit compressed file labels                              */
  362. /*                                                                   */
  363. /*********************************************************************/
  364.  
  365.    switch (output_format)
  366.      {
  367.        case 1: pds_labels(host);
  368.                break;
  369.        case 2: fits_labels(host);
  370.                break;
  371.        case 3: vicar_labels(host);
  372.                break;
  373.        case 4: no_labels(host);
  374.      }
  375. /*********************************************************************/
  376. /*                                                                   */
  377. /* process the image histogram                                       */
  378. /*                                                                   */
  379. /*********************************************************************/
  380.  
  381. /* need to know record_bytes,hist_count,hist_item_type,item_count.*/
  382.    total_bytes = 0;
  383.    length = read_var((char *)hist,host);
  384.    total_bytes = total_bytes + length;
  385.    length = read_var((char *)hist+836,host);
  386.    total_bytes = total_bytes + length;
  387.  
  388.    if (host == 2 || host == 5)             /* If non-byte swapped    */
  389.      for (i=0;i<256;i++)                   /* host, swap bytes in    */
  390.        hist[i] = swap_long(hist[i]);       /* the output histogram   */
  391.  
  392.    if (output_format == 1)
  393.      {
  394.       fwrite((char *)hist,    836,1,outfile);
  395.       fwrite((char *)hist+836,length,1,outfile);
  396.  
  397.       /*  pad out the histogram to a multiple of RECORD_BYTES */
  398.       for (i=total_bytes;i<RECORD_BYTES*2;i++) fputc(blank,outfile);
  399.      }
  400. /*********************************************************************/
  401. /*                                                                   */
  402. /* process the encoding histogram                                    */
  403. /* don't have to byte-swap because DECOMP.C does it for us           */
  404. /*                                                                   */
  405. /*********************************************************************/
  406.  
  407.    length = read_var((char *)hist,host);
  408.    length = read_var((char *)hist+836,host);
  409.    length = read_var((char *)hist+1672,host);
  410.  
  411. /*********************************************************************/
  412. /*                                                                   */
  413. /* process the engineering summary                                   */
  414. /*                                                                   */
  415. /*********************************************************************/
  416.  
  417.    total_bytes = 0;
  418.    length = read_var(ibuf,host);
  419.  
  420.    if (output_format == 1)
  421.      {
  422.       fwrite(ibuf,length,1,outfile);
  423.       total_bytes = total_bytes + length;
  424.  
  425.       /*  pad out engineering to multiple of 836 */
  426.       for (i=total_bytes;i<RECORD_BYTES;i++) fputc(blank,outfile);
  427.      }
  428. /*********************************************************************/
  429. /*                                                                   */
  430. /* initialize the decompression                                      */
  431. /*                                                                   */
  432. /*********************************************************************/
  433.  
  434. /*stupid    fprintf(stderr,"\nInitializing decompression routine..."); */
  435.     decmpinit(hist);
  436.  
  437. /*********************************************************************/
  438. /*                                                                   */
  439. /* decompress the image                                              */
  440. /*                                                                   */
  441. /*********************************************************************/
  442.  
  443. /* stupid
  444.     printf("\nDecompressing data..."); */
  445.     line=0;
  446.     do
  447.       {
  448.        length = read_var(ibuf,host);
  449.        if (length <= 0) break;
  450.        long_length = (long)length;
  451.        line += 1;
  452.        decompress(ibuf, obuf,&long_length, &out_bytes);
  453.        if (output_format == 1)
  454.          {
  455.           count = fwrite(obuf,RECORD_BYTES,1,outfile);
  456.           if (count != 1)
  457.             {
  458.              fprintf(stderr,"\nError writing output file.  Aborting program.");
  459.              fprintf(stderr,"\nCheck disk space or for duplicate file
  460. name (VMS).");
  461.              exit(1);
  462.             }
  463.          }
  464.        else fwrite(obuf,800,1,outfile);
  465.  
  466. /* stupid        if (line % 100 == 0) printf("\n line %d",line);*/
  467.       } while (length > 0 && line < 800);
  468.  
  469.  /*  pad out FITS file to a multiple of 2880 */
  470.  if (output_format == 2)
  471.    for (i=0;i<2240;i++) fputc(blank,outfile);
  472.  
  473. /*stupid printf("\n");*/
  474.  free_tree(&long_length);
  475.  close(infile);
  476.  fclose(outfile);
  477. }
  478.  
  479. /*********************************************************************/
  480. /*                                                                   */
  481. /* subroutine get_files - get input filenames and open               */
  482. /*                                                                   */
  483. /*********************************************************************/
  484.  
  485. int get_files(host)
  486. int host;
  487.  
  488. {
  489. short   shortint;
  490.  
  491.   if (inname[0] == ' ')
  492.     {
  493.      fprintf(stderr,"\nEnter name of file to be decompressed: ");
  494.      gets (inname);
  495.     }
  496.   if (host == 1 | host == 2)
  497.     {
  498.      if ((infile = open(inname,O_RDONLY | O_BINARY)) <= 0)
  499.        {
  500.         fprintf(stderr,"\ncan't open input file: %s\n",inname);
  501.         exit(1);
  502.        }
  503.     }
  504.   else if (host == 3 | host == 5)
  505.     {
  506.      if ((infile = open(inname,O_RDONLY)) <= 0)
  507.        {
  508.         fprintf(stderr,"\ncan't open input file: %s\n",inname);
  509.         exit(1);
  510.        }
  511.  
  512.   /****************************************************************/
  513.   /* If we are on a vax see if the file is in var length format.  */
  514.   /* This logic is in here in case the vax file has been stored   */
  515.   /* in fixed or undefined format.  This might be necessary since */
  516.   /* vax variable length files can't be moved to other computer   */
  517.   /* systems with standard comm programs (kermit, for example).   */
  518.   /****************************************************************/
  519.  
  520.      if (host == 3)
  521.        {
  522.         read(infile,&shortint,2);
  523.         if (shortint > 0 && shortint < 80)
  524.           {
  525.            host = 4;              /* change host to 4                */
  526.            fprintf(stderr,"This is not a VMS variable length file.");
  527.           }
  528.         else fprintf(stderr,"This is a VMS variable length file.");
  529.         lseek(infile,0,0);        /* reposition to beginning of file */
  530.        }
  531.     }
  532.  
  533.   if (output_format == 0)
  534.   do
  535.     {
  536.      fprintf(stderr,"\nEnter a number for the output format desired:\n");
  537.      fprintf(stderr,"\n  1.  SFDU/PDS format.");
  538.      fprintf(stderr,"\n  2.  FITS format.");
  539.      fprintf(stderr,"\n  3.  VICAR format.");
  540.      fprintf(stderr,"\n  4.  Unlabelled binary array.\n");
  541.      fprintf(stderr,"\n  Enter format number:");
  542.      gets(inname);
  543.      output_format = atoi(inname);
  544.     } while (output_format < 1 || output_format > 4);
  545.  
  546.   if (outname[0] == ' ')
  547.     {
  548.      fprintf(stderr,"\nEnter name of uncompressed output file: ");
  549.      gets (outname);
  550.     }
  551.  
  552.   if (*outname == '-') {    /* write to stdout */
  553.     outfile = stdout;
  554.     return(host);
  555.   }
  556.   if (host == 1 || host == 2 || host == 5)
  557.     {
  558.      if ((outfile = fopen(outname,"wb"))==NULL)
  559.        {
  560.         fprintf(stderr,"\ncan't open output file: %s\n",outname);
  561.         exit(1);
  562.        }
  563.     }
  564. /* ANSI C doesn't like the extra crappy arguments to fopen below */
  565. #ifndef __unix__
  566.   else if (host == 3 || host == 4)
  567.     {
  568.      if (output_format == 1)      /* write PDS format blocks */
  569.        {
  570.         if ((outfile=fopen(outname,"w",
  571.                            "mrs=836",FOP,CTX,RECORD_TYPE))==NULL)
  572.          {
  573.           fprintf(stderr,"\ncan't open output file: %s\n",outname);
  574.           exit(1);
  575.          }
  576.        }
  577.      else if (output_format == 2) /* write FITS format blocks */
  578.        {
  579.         if ((outfile=fopen(outname,"w",
  580.                            "mrs=2880",FOP,CTX,RECORD_TYPE))==NULL)
  581.          {
  582.           fprintf(stderr,"\ncan't open output file: %s\n",outname);
  583.           exit(1);
  584.          }
  585.        }
  586.      else                         /* write 800 byte records */
  587.        {
  588.         if ((outfile=fopen(outname,"w",
  589.                            "mrs=800",FOP,CTX,RECORD_TYPE))==NULL)
  590.          {
  591.           fprintf(stderr,"\ncan't open output file: %s\n",outname);
  592.           exit(1);
  593.          }
  594.        }
  595.     }
  596. #endif
  597.   return(host);  /* In case its been updated */
  598. }
  599.  
  600. /*********************************************************************/
  601. /*                                                                   */
  602. /* subroutine pds_labels - edit PDS labels and write to output file  */
  603. /*                                                                   */
  604. /*********************************************************************/
  605.  
  606. void pds_labels(host)
  607. int host;
  608.  
  609. {
  610. char          outstring[80],ibuf[2048];
  611. unsigned char cr=13,lf=10,blank=32;
  612. short         length,nlen,total_bytes,line,i;
  613.  
  614.  
  615. total_bytes = 0;
  616. do
  617.   {
  618.    length = read_var(ibuf,host);
  619.    ibuf[length]=NULL;
  620.  
  621.   /******************************************************************/
  622.   /*  edit labels which need to be changed                          */
  623.   /******************************************************************/
  624.  
  625.    if      ((i = strncmp(ibuf,"NJPL1I00PDS1",12)) == 0)
  626.    /*****************************************************************/
  627.    /* add the output file length to the sfdu label                  */
  628.    /*****************************************************************/
  629.      {
  630.       strcpy(outstring,ibuf);
  631.       strcpy(outstring+12,"00673796");
  632.       strcpy(outstring+20,ibuf+20);
  633.       fwrite(outstring,length,1,outfile);
  634.       fprintf(outfile,"%c%c",cr,lf);
  635.       total_bytes = total_bytes + length + 2;
  636.      }
  637.    else if ((i = strncmp(ibuf,"RECORD_TYPE",11)) == 0)
  638.    /*****************************************************************/
  639.    /* change the record_type value from variable to fixed           */
  640.    /*****************************************************************/
  641.      {
  642.       strcpy(ibuf+35,"FIXED_LENGTH");
  643.       length = length - 3;
  644.       fwrite(ibuf,length,1,outfile);
  645.       fprintf(outfile,"%c%c",cr,lf);
  646.       total_bytes = total_bytes + length + 2;
  647.      }
  648.    else if ((i = strncmp(ibuf,"FILE_RECORDS",12)) == 0)
  649.    /*****************************************************************/
  650.    /* change the file_records count to 806                          */
  651.    /*****************************************************************/
  652.      {
  653.       strcpy(ibuf+35,"806");
  654.       fwrite(ibuf,length,1,outfile);
  655.       fprintf(outfile,"%c%c",cr,lf);
  656.       total_bytes = total_bytes + length + 2;
  657.      }
  658.    else if ((i = strncmp(ibuf,"LABEL_RECORDS",13)) == 0)
  659.    /*****************************************************************/
  660.   /* change the label_records count from 56 to 3                    */
  661.    /*****************************************************************/
  662.      {
  663.       strcpy(ibuf+35,"3");
  664.       length -= 1;
  665.       fwrite(ibuf,length,1,outfile);
  666.       fprintf(outfile,"%c%c",cr,lf);
  667.       total_bytes = total_bytes + length + 2;
  668.      }
  669.    else if ((i = strncmp(ibuf,"^IMAGE_HISTOGRAM",16)) == 0)
  670.    /*****************************************************************/
  671.    /* change the location pointer of image_histogram to record 4    */
  672.    /*****************************************************************/
  673.      {
  674.       strcpy(ibuf+35,"4");
  675.       length -= 1;
  676.       fwrite(ibuf,length,1,outfile);
  677.       fprintf(outfile,"%c%c",cr,lf);
  678.       total_bytes = total_bytes + length + 2;
  679.      }
  680.    else if ((i = strncmp(ibuf,"^ENCODING_HISTOGRAM)",19)) == 0);
  681.    /*****************************************************************/
  682.    /* delete the encoding_histogram location pointer                */
  683.    /*****************************************************************/
  684.    else if ((i = strncmp(ibuf,"^ENGINEERING_TABLE",18)) == 0)
  685.    /*****************************************************************/
  686.    /* change the location pointer of engineering_summary to record 6*/
  687.    /*****************************************************************/
  688.      {
  689.       strcpy(ibuf+35,"6");
  690.       length -= 1;
  691.       fwrite(ibuf,length,1,outfile);
  692.       fprintf(outfile,"%c%c",cr,lf);
  693.       total_bytes = total_bytes + length + 2;
  694.      }
  695.    else if ((i = strncmp(ibuf,"^IMAGE",6)) == 0)
  696.    /*****************************************************************/
  697.    /* change the location pointer of image to record 7              */
  698.    /*****************************************************************/
  699.      {
  700.       strcpy(ibuf+35,"7");
  701.       length = length -1;
  702.       fwrite(ibuf,length,1,outfile);
  703.       fprintf(outfile,"%c%c",cr,lf);
  704.       total_bytes = total_bytes + length + 2;
  705.      }
  706.    else if ((i = strncmp(ibuf,
  707.              "OBJECT                           = ENCODING",43)) == 0)
  708.    /*****************************************************************/
  709.    /* delete the 4 encoding histogram labels                        */
  710.    /*****************************************************************/
  711.      {
  712.       for (i=0;i<4;i++)   /* ignore these labels */
  713.         {
  714.          length = read_var(ibuf,host);
  715.         }
  716.      }
  717.    else if ((i = strncmp(ibuf," ENCODING",9)) == 0);
  718.    /*****************************************************************/
  719.    /* delete the encoding type label in the image object            */
  720.    /*****************************************************************/
  721.    else if ((host == 2 || host == 5) && (i = strncmp(ibuf,
  722.              " ITEM_TYPE                       = VAX_INTEGER",46)) == 0)
  723.    /*****************************************************************/
  724.    /* change the record_type value from variable to fixed           */
  725.    /*****************************************************************/
  726.      {
  727.       strcpy(ibuf+35,"INTEGER");
  728.       length = length - 4;
  729.       fwrite(ibuf,length,1,outfile);
  730.       fprintf(outfile,"%c%c",cr,lf);
  731.       total_bytes = total_bytes + length + 2;
  732.      }
  733.  
  734.  
  735.  
  736.    /*****************************************************************/
  737.    /* if none of above write out the label to the output file       */
  738.    /*****************************************************************/
  739.    else
  740.      {
  741.       fwrite(ibuf,length,1,outfile);
  742.       fprintf(outfile,"%c%c",cr,lf);
  743.       total_bytes = total_bytes + length + 2;
  744.      }
  745.    /*****************************************************************/
  746.    /* test for the end of the PDS labels                            */
  747.    /*****************************************************************/
  748.    if ((i = strncmp(ibuf,"END",3)) == 0 && length == 3) break;
  749.   } while (length > 0);
  750.  
  751. /* pad out the labels with blanks to multiple of RECORD_BYTES */
  752.    for (i=total_bytes;i<RECORD_BYTES*3;i++) fputc(blank,outfile);
  753. }
  754.  
  755. /*********************************************************************/
  756. /*                                                                   */
  757. /* subroutine fits_labels - write FITS header to output file */
  758. /*                                                                   */
  759. /*********************************************************************/
  760.  
  761. void fits_labels(host)
  762. int host;
  763.  
  764. {
  765. char          ibuf[2048],outstring[80];
  766. unsigned char cr=13,lf=10,blank=32;
  767. short         length,nlen,total_bytes,line,i;
  768.  
  769. do
  770.   {
  771.    length = read_var(ibuf,host);
  772.    /*****************************************************************/
  773.    /* read to the end of the PDS labels                             */
  774.    /*****************************************************************/
  775.    if ((i = strncmp(ibuf,"END",3)) == 0 && length == 3) break;
  776.   } while (length > 0);
  777.  
  778. total_bytes = 0;
  779.  
  780. strcpy(outstring,
  781. "SIMPLE  =                    T                                         
  782.       ");
  783. fwrite(outstring,78,1,outfile);
  784. fprintf(outfile,"%c%c",cr,lf);
  785. total_bytes = total_bytes + 80;
  786.  
  787. strcpy(outstring,
  788. "BITPIX  =                    8                                         
  789.       ");
  790. fwrite(outstring,78,1,outfile);
  791. fprintf(outfile,"%c%c",cr,lf);
  792. total_bytes = total_bytes + 80;
  793.  
  794. strcpy(outstring,
  795. "NAXIS   =                    2                                         
  796.       ");
  797. fwrite(outstring,78,1,outfile);
  798. fprintf(outfile,"%c%c",cr,lf);
  799. total_bytes = total_bytes + 80;
  800.  
  801. strcpy(outstring,
  802. "NAXIS1  =                  800                                         
  803.       ");
  804. fwrite(outstring,78,1,outfile);
  805. fprintf(outfile,"%c%c",cr,lf);
  806. total_bytes = total_bytes + 80;
  807.  
  808. strcpy(outstring,
  809. "NAXIS2  =                  800                                         
  810.       ");
  811. fwrite(outstring,78,1,outfile);
  812. fprintf(outfile,"%c%c",cr,lf);
  813. total_bytes = total_bytes + 80;
  814.  
  815. strcpy(outstring,
  816. "END                                                                    
  817.       ");
  818. fwrite(outstring,78,1,outfile);
  819. fprintf(outfile,"%c%c",cr,lf);
  820. total_bytes = total_bytes + 80;
  821.  
  822. /* pad out the labels with blanks to multiple of RECORD_BYTES */
  823.    for (i=total_bytes;i<2880;i++) fputc(blank,outfile);
  824. }
  825.  
  826. /*********************************************************************/
  827. /*                                                                   */
  828. /* subroutine vicar_labels - write vicar labels to output file       */
  829. /*   (really, really shouldn't assume 800x800                 */
  830. /*********************************************************************/
  831.  
  832. void vicar_labels(host)
  833. int host;
  834.  
  835. {
  836. char          ibuf[2048],outstring[80];
  837. unsigned char cr=13,lf=10,blank=32;
  838. short         length,nlen,total_bytes,line,i;
  839.  
  840. do
  841.   {
  842.    length = read_var(ibuf,host);
  843.    /*****************************************************************/
  844.    /* read to the end of the PDS labels                             */
  845.    /*****************************************************************/
  846.    if ((i = strncmp(ibuf,"END",3)) == 0 && length == 3) break;
  847.   } while (length > 0);
  848.  
  849. total_bytes = 0;
  850.  
  851. strcpy(outstring,
  852. "LBLSIZE=800             FORMAT='BYTE'  TYPE='IMAGE'  BUFSIZ=800  DIM=2  ");
  853. fwrite(outstring,72,1,outfile);
  854. total_bytes = total_bytes + 72;
  855. strcpy(outstring,
  856. "EOL=0  RECSIZE=800  ORG='BSQ'  NL=800  NS=800  NB=1  N1=0  N2=0  N3=0  ");
  857. total_bytes = total_bytes + 71;
  858. fwrite(outstring,71,1,outfile);
  859. strcpy(outstring,
  860. "N4=0  NBB=0  NLB=0");
  861. fwrite(outstring,18,1,outfile);
  862. fprintf(outfile,"%c%c",cr,lf);
  863. total_bytes = total_bytes + 20;
  864.  
  865. /* pad out the labels with blanks to multiple of RECORD_BYTES */
  866.    for (i=total_bytes;i<800;i++) fputc(blank,outfile);
  867. }
  868.  
  869. /*********************************************************************/
  870. /*                                                                   */
  871. /* subroutine no_labels - read past the pds labels                   */
  872. /*                                                                   */
  873. /*********************************************************************/
  874.  
  875. void no_labels(host)
  876. int host;
  877.  
  878. {
  879. char          ibuf[2048],outstring[80];
  880. unsigned char cr=13,lf=10,blank=32;
  881. short         length,nlen,total_bytes,line,i;
  882.  
  883. do
  884.   {
  885.    length = read_var(ibuf,host);
  886.    /*****************************************************************/
  887.    /* read to the end of the PDS labels                             */
  888.    /*****************************************************************/
  889.    if ((i = strncmp(ibuf,"END",3)) == 0 && length == 3) break;
  890.   } while (length > 0);
  891.  
  892. }
  893.  
  894.  
  895. /*********************************************************************/
  896. /*                                                                   */
  897. /* subroutine read_var - read variable length records from input file*/
  898. /*                                                                   */
  899. /*********************************************************************/
  900.  
  901. read_var(ibuf,host)
  902. char  *ibuf;
  903. int   host;
  904. {
  905. int   length,result,nlen;
  906. char  temp;
  907. union /* this union is used to swap 16 and 32 bit integers          */
  908.   {
  909.    char  ichar[4];
  910.    short slen;
  911.    long  llen;
  912.   } onion;
  913.  
  914.   switch (host)
  915.     {
  916.      case 1: /*******************************************************/
  917.              /* IBM PC host                                         */
  918.              /*******************************************************/
  919.        length = 0;
  920.        result = read(infile,&length,2);
  921.        nlen =   read(infile,ibuf,length+(length%2));
  922.        return (length);
  923.        break;
  924.  
  925.      case 2: /*******************************************************/
  926.              /* Macintosh host                                      */
  927.              /*******************************************************/
  928.        length = 0;
  929.        result = read(infile,onion.ichar,2);
  930.        /*     byte swap the length field                            */
  931.        temp   = onion.ichar[0];
  932.        onion.ichar[0]=onion.ichar[1];
  933.        onion.ichar[1]=temp;
  934.        length = onion.slen;       /* left out of earlier versions   */
  935.        /* printf("length=%04x,result=%d\n",length,result);          */
  936.        nlen =   read(infile,ibuf,length+(length%2));
  937.        return (length);
  938.        break;
  939.  
  940.      case 3: /*******************************************************/
  941.              /* VAX host with variable length support               */
  942.              /*******************************************************/
  943.        length = read(infile,ibuf,RECORD_BYTES);
  944.        return (length);
  945.  
  946.      case 4: /*******************************************************/
  947.              /* VAX host, but not a variable length file            */
  948.              /*******************************************************/
  949.        length = 0;
  950.        result = read(infile,&length,2);
  951.        nlen =   read(infile,ibuf,length+(length%2));
  952.  
  953.        /* check to see if we crossed a vax record boundary          */
  954.        while (nlen < length)
  955.          nlen += read(infile,ibuf+nlen,length+(length%2)-nlen);
  956.        return (length);
  957.        break;
  958.  
  959.      case 5: /*******************************************************/
  960.              /* Unix workstation host (non-byte-swapped 32 bit host)*/
  961.              /*******************************************************/
  962.        length = 0;
  963.        result = read(infile,onion.ichar,2);
  964.        /*     byte swap the length field                            */
  965.        temp   = onion.ichar[0];
  966.        onion.ichar[0]=onion.ichar[1];
  967.        onion.ichar[1]=temp;
  968.        length = onion.slen;
  969.        /* printf("length=%04x,result=%d\n",length,result); */
  970.        nlen =   read(infile,ibuf,length+(length%2));
  971.        return (length);
  972.        break;
  973.     }
  974. }
  975.  
  976. /*********************************************************************/
  977. /*                                                                   */
  978. /* subroutine check_host - find out what kind of machine we are on   */
  979. /*                                                                   */
  980. /*********************************************************************/
  981.  
  982. int check_host()
  983. {
  984. /*  This subroutine checks the attributes of the host computer and
  985.     returns a host code number.
  986. */
  987. char hostname[80];
  988.  
  989. int swap,host,bits,var;
  990. union
  991.   {
  992.    char  ichar[2];
  993.    short ilen;
  994.   } onion;
  995.  
  996. if (sizeof(var) == 4) bits = 32;
  997.                  else bits = 16;
  998.  
  999. onion.ichar[0] = 1;
  1000. onion.ichar[1] = 0;
  1001.  
  1002. if (onion.ilen == 1) swap = TRUE;
  1003. else                 swap = FALSE;
  1004.  
  1005. if (bits == 16 && swap == TRUE)
  1006.   {
  1007.    host = 1; /* IBM PC host  */
  1008.    strcpy(hostname,
  1009.           "Host 1 - 16 bit integers with swapping, no var len support.");
  1010.   }
  1011.  
  1012. if (bits == 16 && swap == FALSE)
  1013.   {
  1014.    host = 2; /* Non byte swapped 16 bit host  */
  1015.    strcpy(hostname,
  1016.           "Host 2 - 16 bit integers without swapping, no var len support.");
  1017.   }
  1018.  
  1019. if (bits == 32 && swap == TRUE)
  1020.  { host = 3; /* VAX host with var length support */
  1021.    strcpy(hostname,
  1022.           "Host 3,4 - 32 bit integers with swapping.");
  1023.  }
  1024.  
  1025. if (bits == 32 && swap == FALSE)
  1026.   {
  1027.    host = 5; /* OTHER 32-bit host  */
  1028.    strcpy(hostname,
  1029.           "Host 5 - 32 bit integers without swapping, no var len support.");
  1030.   }
  1031.  
  1032. if ((Argc >= 3) && (*outname != '-')) /* suppress if stdout (-) on cmdline */
  1033.     fprintf(stderr,"%s\n",hostname);
  1034. return(host);
  1035. }
  1036.  
  1037. long swap_long(inval)  /* swap 4 byte integer                       */
  1038. long inval;
  1039. {
  1040. union /* this union is used to swap 16 and 32 bit integers          */
  1041.   {
  1042.    char  ichar[4];
  1043.    short slen;
  1044.    long  llen;
  1045.   } onion;
  1046.   char   temp;
  1047.  
  1048.   /* byte swap the input field                                      */
  1049.   onion.llen   = inval;
  1050.   temp   = onion.ichar[0];
  1051.   onion.ichar[0]=onion.ichar[3];
  1052.   onion.ichar[3]=temp;
  1053.   temp   = onion.ichar[1];
  1054.   onion.ichar[1]=onion.ichar[2];
  1055.   onion.ichar[2]=temp;
  1056.   return (onion.llen);
  1057. }
  1058.  
  1059.  void decompress(ibuf,obuf,nin,nout)
  1060. /****************************************************************************
  1061. *_TITLE decompress - decompresses image lines stored in compressed format   *
  1062. *_ARGS  TYPE       NAME      I/O        DESCRIPTION                         */
  1063.         char       *ibuf;  /* I         Compressed data buffer              */
  1064.         char       *obuf;  /* O         Decompressed image line             */
  1065.         long int   *nin;   /* I         Number of bytes on input buffer     */
  1066.         long int   *nout;  /* I         Number of bytes in output buffer    */
  1067.  
  1068.   {
  1069.  /* The external root pointer to tree */
  1070.     extern NODE *tree;
  1071.  
  1072.  /* Declare functions called from this routine */
  1073.     void dcmprs();
  1074.  
  1075. /*************************************************************************
  1076.   This routine is fairly simple as it's only function is to call the
  1077.   routine dcmprs.
  1078. **************************************************************************/
  1079.  
  1080.     dcmprs(ibuf,obuf,nin,nout,tree);
  1081.  
  1082.     return;
  1083.   }
  1084.  
  1085. void decmpinit(hist)
  1086. /***************************************************************************
  1087. *_TITLE decmpinit - initializes the Huffman tree                           *
  1088. *_ARGS  TYPE       NAME      I/O        DESCRIPTION                        */
  1089.         long int   *hist;  /* I         First-difference histogram.        */
  1090.  
  1091. {
  1092.   extern NODE *tree;          /* Huffman tree root pointer */
  1093.  
  1094.   /* Specify the calling function to initialize the tree */
  1095.   NODE *huff_tree();
  1096.  
  1097. /****************************************************************************
  1098.   Simply call the huff_tree routine and return.
  1099. *****************************************************************************/
  1100.  
  1101.   tree = huff_tree(hist);
  1102.  
  1103.   return;
  1104.  }
  1105.  
  1106. NODE *huff_tree(hist)
  1107. /****************************************************************************
  1108. *_TITLE huff_tree - constructs the Huffman tree; returns pointer to root    *
  1109. *_ARGS  TYPE          NAME        I/O   DESCRIPTION                         */
  1110.         long int     *hist;     /* I    First difference histogram          */
  1111.  
  1112.   {
  1113.   /*  Local variables used */
  1114.     long int freq_list[512];      /* Histogram frequency list */
  1115.     NODE **node_list;             /* DN pointer array list */
  1116.  
  1117.     register long int *fp;        /* Frequency list pointer */
  1118.     register NODE **np;           /* Node list pointer */
  1119.  
  1120.     register long int num_freq;   /* Number non-zero frequencies in
  1121. histogram */
  1122.     long int sum;                 /* Sum of all frequencies */
  1123.  
  1124.     register short int num_nodes; /* Counter for DN initialization */
  1125.     register short int cnt;       /* Miscellaneous counter */
  1126.  
  1127.     short int znull = -1;         /* Null node value */
  1128.  
  1129.     register NODE *temp;          /* Temporary node pointer */
  1130.  
  1131.   /* Functions called */
  1132.     void sort_freq();
  1133.     NODE *new_node();
  1134.     char *malloc();
  1135.  
  1136. /***************************************************************************
  1137.   Allocate the array of nodes from memory and initialize these with numbers
  1138.   corresponding with the frequency list.  There are only 511 possible
  1139.   permutations of first difference histograms.  There are 512 allocated
  1140.   here to adhere to the FORTRAN version.
  1141. ****************************************************************************/
  1142.  
  1143.    fp = freq_list;
  1144.    node_list = (NODE **) malloc(sizeof(temp)*512);
  1145.    if (node_list == NULL)
  1146.     {
  1147.       fprintf(stderr,"\nOut of memory in huff_tree!\n");
  1148.       exit(1);
  1149.     }
  1150.    np = node_list;
  1151.  
  1152.    for (num_nodes=1, cnt=512 ; cnt-- ; num_nodes++)
  1153.      {
  1154. /**************************************************************************
  1155.     The following code has been added to standardize the VAX byte order
  1156.     for the "long int" type.  This code is intended to make the routine
  1157.     as machine independant as possible.
  1158. ***************************************************************************/
  1159.         unsigned char *cp = (unsigned char *) hist++;
  1160.         unsigned long int j;
  1161.         short int i;
  1162.         for (i=4 ; --i >= 0 ; j = (j << 8) | *(cp+i));
  1163.  
  1164. /* Now make the assignment */
  1165.         *fp++ = j;
  1166.         temp = new_node(num_nodes);
  1167.         *np++ = temp;
  1168.      }
  1169.  
  1170.      (*--fp) = 0;         /* Ensure the last element is zeroed out.  */
  1171.  
  1172. /***************************************************************************
  1173.   Now, sort the frequency list and eliminate all frequencies of zero.
  1174. ****************************************************************************/
  1175.  
  1176.   num_freq = 512;
  1177.   sort_freq(freq_list,node_list,num_freq);
  1178.  
  1179.   fp = freq_list;
  1180.   np = node_list;
  1181.  
  1182.   for (num_freq=512 ; (*fp) == 0 && (num_freq) ; fp++, np++, num_freq--);
  1183.  
  1184.  
  1185. /***************************************************************************
  1186.   Now create the tree.  Note that if there is only one difference value,
  1187.   it is returned as the root.  On each interation, a new node is created
  1188.   and the least frequently occurring difference is assigned to the right
  1189.   pointer and the next least frequency to the left pointer.  The node
  1190.   assigned to the left pointer now becomes the combination of the two
  1191.   nodes and it's frequency is the sum of the two combining nodes.
  1192. ****************************************************************************/
  1193.  
  1194.   for (temp=(*np) ; (num_freq--) > 1 ; )
  1195.     {
  1196.         temp = new_node(znull);
  1197.         temp->right = (*np++);
  1198.         temp->left = (*np);
  1199.         *np = temp;
  1200.         *(fp+1) = *(fp+1) + *fp;
  1201.         *fp++ = 0;
  1202.         sort_freq(fp,np,num_freq);
  1203.     }
  1204.  
  1205.   return temp;
  1206.  }
  1207.  
  1208. NODE *new_node(value)
  1209. /****************************************************************************
  1210. *_TITLE new_node - allocates a NODE structure and returns a pointer to it   *
  1211. *_ARGS  TYPE        NAME        I/O     DESCRIPTION                         */
  1212.         short int   value;    /* I      Value to assign to DN field         */
  1213.  
  1214.   {
  1215.     NODE *temp;         /* Pointer to the memory block */
  1216.  
  1217.   char *malloc();       /* Memory allocation function */
  1218.  
  1219. /***************************************************************************
  1220.   Allocate the memory and intialize the fields.
  1221. ****************************************************************************/
  1222.  
  1223.   temp = (NODE *) malloc(sizeof(NODE));
  1224.  
  1225.   if (temp != NULL)
  1226.     {
  1227.       temp->right = NULL;
  1228.       temp->dn = value;
  1229.       temp->left = NULL;
  1230.     }
  1231.   else
  1232.     {
  1233.        fprintf(stderr,"\nOut of memory in new_node!\n");
  1234.        exit(1);
  1235.     }
  1236.  
  1237.    return temp;
  1238.   }
  1239.  
  1240.  void sort_freq(freq_list,node_list,num_freq)
  1241. /****************************************************************************
  1242. *_TITLE sort_freq - sorts frequency and node lists in increasing freq. order*
  1243. *_ARGS  TYPE       NAME            I/O  DESCRIPTION                         */
  1244.         long int   *freq_list;   /* I   Pointer to frequency list           */
  1245.         NODE       **node_list;  /* I   Pointer to array of node pointers   */
  1246.         long int   num_freq;     /* I   Number of values in freq list       */
  1247.  
  1248.   {
  1249.     /* Local Variables */
  1250.     register long int *i;       /* primary pointer into freq_list */
  1251.     register long int *j;       /* secondary pointer into freq_list */
  1252.  
  1253.     register NODE **k;          /* primary pointer to node_list */
  1254.     register NODE **l;          /* secondary pointer into node_list */
  1255.  
  1256.     long int temp1;             /* temporary storage for freq_list */
  1257.     NODE *temp2;                /* temporary storage for node_list */
  1258.  
  1259.     register long int cnt;      /* count of list elements */
  1260.  
  1261.  
  1262. /************************************************************************
  1263.   Save the current element - starting with the second - in temporary
  1264.   storage.  Compare with all elements in first part of list moving
  1265.   each up one element until the element is larger.  Insert current
  1266.   element at this point in list.
  1267. *************************************************************************/
  1268.  
  1269.    if (num_freq <= 0) return;      /* If no elements or invalid, return */
  1270.  
  1271.    for (i=freq_list, k=node_list, cnt=num_freq ; --cnt ; *j=temp1, *l=temp2)
  1272.      {
  1273.         temp1 = *(++i);
  1274.         temp2 = *(++k);
  1275.  
  1276.         for (j = i, l = k ;  *(j-1) > temp1 ; )
  1277.           {
  1278.             *j = *(j-1);
  1279.             *l = *(l-1);
  1280.             j--;
  1281.             l--;
  1282.             if ( j <= freq_list) break;
  1283.           }
  1284.  
  1285.      }
  1286.   return;
  1287.   }
  1288.  
  1289.  void dcmprs(ibuf,obuf,nin,nout,root)
  1290. /****************************************************************************
  1291. *_TITLE dcmprs - decompresses Huffman coded compressed image lines          *
  1292. *_ARGS  TYPE       NAME       I/O       DESCRIPTION                         */
  1293.         char       *ibuf;   /* I        Compressed data buffer              */
  1294.         char       *obuf;   /* O        Decompressed image line             */
  1295.         long int   *nin;    /* I        Number of bytes on input buffer     */
  1296.         long int   *nout;   /* I        Number of bytes in output buffer    */
  1297.         NODE       *root;   /* I        Huffman coded tree                  */
  1298.  
  1299.   {
  1300.     /* Local Variables */
  1301.     register NODE *ptr = root;        /* pointer to position in tree */
  1302.     register unsigned char test;      /* test byte for bit set */
  1303.     register unsigned char idn;       /* input compressed byte */
  1304.  
  1305.     register char odn;                /* last dn value decompressed */
  1306.  
  1307.     char *ilim = ibuf + *nin;         /* end of compressed bytes */
  1308.     char *olim = obuf + *nout;        /* end of output buffer */
  1309.  
  1310. /**************************************************************************
  1311.   Check for valid input values for nin, nout and make initial assignments.
  1312. ***************************************************************************/
  1313.  
  1314.     if (ilim > ibuf && olim > obuf)
  1315.        odn = *obuf++ = *ibuf++;
  1316.     else
  1317.        {
  1318.            fprintf(stderr,"\nInvalid byte count in dcmprs!\n");
  1319.            exit(1);
  1320.        }
  1321.  
  1322. /**************************************************************************
  1323.   Decompress the input buffer.  Assign the first byte to the working
  1324.   variable, idn.  An arithmatic and (&) is performed using the variable
  1325.   'test' that is bit shifted to the right.  If the result is 0, then
  1326.   go to right else go to left.
  1327. ***************************************************************************/
  1328.  
  1329.     for (idn=(*ibuf) ; ibuf < ilim  ; idn =(*++ibuf))
  1330.      {
  1331.         for (test=0x80 ; test ; test >>= 1)
  1332.            {
  1333.             ptr = (test & idn) ? ptr->left : ptr->right;
  1334.  
  1335.             if (ptr->dn != -1)
  1336.               {
  1337.                 if (obuf >= olim) return;
  1338.                 odn -= ptr->dn + 256;
  1339.                 *obuf++ = odn;
  1340.                 ptr = root;
  1341.               }
  1342.           }
  1343.      }
  1344.    return;
  1345.   }
  1346.  
  1347.  
  1348. void free_tree(nfreed)
  1349. /****************************************************************************
  1350. *_TITLE free_tree - free memory of all allocated nodes                      *
  1351. *_ARGS  TYPE       NAME       I/O        DESCRIPTION                        */
  1352.         long int   *nfreed;  /* O        Return of total count of nodes     *
  1353. *                                        freed.                             */
  1354.  
  1355. /*
  1356. *_DESCR This routine is supplied to the programmer to free up all the       *
  1357. *       allocated memory required to build the huffman tree.  The count     *
  1358. *       of the nodes freed is returned in the parameter 'nfreed'.  The      *
  1359. *       purpose of the routine is so if the user wishes to decompress more  *
  1360. *       than one file per run, the program will not keep allocating new     *
  1361. *       memory without first deallocating all previous nodes associated     *
  1362. *       with the previous file decompression.                               *
  1363.  
  1364. *_HIST  16-AUG-89 Kris Becker   USGS, Flagstaff Original Version            *
  1365. *_END                                                                       *
  1366. ****************************************************************************/
  1367.  
  1368. {
  1369.     long int total_free = 0;
  1370.  
  1371.     extern NODE *tree;      /* Huffman tree root pointer */
  1372.  
  1373. /* Specify the function to free the tree */
  1374.     long int free_node();
  1375. /****************************************************************************
  1376.   Simply call the free_node routine and return the result.
  1377. *****************************************************************************/
  1378.  
  1379.     *nfreed = free_node(tree,total_free);
  1380.  
  1381.     return;
  1382. }
  1383.  
  1384. long int free_node(pnode,total_free)
  1385. /***************************************************************************
  1386. *_TITLE free_node - deallocates an allocated NODE pointer
  1387. *_ARGS  TYPE     NAME          I/O   DESCRIPTION                           */
  1388.         NODE     *pnode;       /* I  Pointer to node to free               */
  1389.         long int total_free;   /* I  Total number of freed nodes           */
  1390.  
  1391. /*
  1392. *_DESCR  free_node will check both right and left pointers of a node       *
  1393. *        and then free the current node using the free() C utility.        *
  1394. *        Note that all nodes attached to the node via right or left        *
  1395. *        pointers area also freed, so be sure that this is the desired     *
  1396. *        result when calling this routine.                                 *
  1397.  
  1398. *        This routine is supplied to allow successive calls to the         *
  1399. *        decmpinit routine.  It will free up the memory allocated          *
  1400. *        by previous calls to the decmpinit routine.  The call to free     *
  1401. *        a previous huffman tree is:  total = free_node(tree,(long) 0);    *
  1402. *        This call must be done by the programmer application routine      *
  1403. *        and is not done by any of these routines.                         *
  1404. *_HIST   16-AUG-89  Kris Becker U.S.G.S  Flagstaff Original Version        */
  1405. {
  1406.     if (pnode == (NODE *) NULL) return(total_free);
  1407.     
  1408.     if (pnode->right != (NODE *) NULL)
  1409.         total_free = free_node(pnode->right,total_free);
  1410.     if (pnode->left != (NODE *) NULL)
  1411.         total_free = free_node(pnode->left,total_free);
  1412.  
  1413.     free((char *) pnode);
  1414.     return(total_free + 1);
  1415. }
  1416.  
  1417. @//E*O*F pdsuncomp.c//
  1418. chmod u=rw,g=r,o=r pdsuncomp.c
  1419.  
  1420. echo x - xvpds.c
  1421. sed 's/^@//' > "xvpds.c" <<'@//E*O*F xvpds.c//'
  1422. /*
  1423.  * xvpds.c - load routine for astronomical PDS/VICAR format pictures
  1424.  *
  1425.  * Anthony A. Datri
  1426.  * Convex Computer Corp
  1427.  * 3000 Waterview Parkway
  1428.  * Ricardson, TX 75080
  1429.  * datri@convex.com
  1430.  *
  1431.  * 9-2-91    began integration.     Much of this code is lifted from vicar.c,
  1432.  *         which I wrote for xloadimage.  This is a little simpler, though.
  1433.  * code to identify and read in PDS/VICAR images, as found on the CD-ROMS from
  1434.  * NASA, and on ames.arc.nasa.gov.
  1435.  *
  1436.  * 10-17-91  pdsuncomp is called with system(), which typically feeds the
  1437.  *         commandline to sh.  Make sure that your .profile adds wherever
  1438.  *         you have pdsuncomp to the PATH, like
  1439.  *
  1440.  *        PATH=$PATH:/usr/local/bin
  1441.  *
  1442.  *
  1443.  * Sources of these CD's:
  1444.  *
  1445.  *  National Space Science Data Center
  1446.  *  Goddard Space Flight Center
  1447.  *  Code 933.4
  1448.  *  Greenbelt, Maryland  
  1449.  *  (301) 286-6695
  1450.  *   or call
  1451.  *  (301) 286-9000 (300,1200,2400 bps)
  1452.  *   or telnet
  1453.  *  nssdca.gsfc.nasa.gov (128.183.10.4) and log in as 'NODIS' (no password).
  1454.  *
  1455.  *  Randy Davis
  1456.  *  LASP
  1457.  *  University of Colorado
  1458.  *  Boulder CO 80309-0392
  1459.  *  (303) 492-6867
  1460.  * These CD's are reasonably priced.  Encourage the continue production
  1461.  * of them by buying a set.
  1462.  * There are three types of files that we deal with here.  I'll call them
  1463.  * PDS-labeled, PDS-labeled Huffman-encoded, and VICAR.  Each consists of data
  1464.  * prefixed with a set of ASCII headers.  PDS-labeled and VICAR files are raw
  1465.  * grayscale data, the dimensions of which can be found from the headers.
  1466.  * PDS-labeled, Huffman-encoded files have the image information adaptively
  1467.  * Huffman-encoded, and the encoding histogram follows the ASCII headers.
  1468.  * To decode these, we use an extended version of "cdcomp.c" from the
  1469.  * NASA Vger CD-ROMS.  For this to work, you need to have pdscomp compiled
  1470.  * and in your path.  pdscomp.c should be included with this distribution.
  1471.  * I've heard that newer discs have FITS images on them.  If they do, support
  1472.  * for them will be added when I get one.  Until then, you can use fitstopgm.
  1473.  *
  1474.  * strstr is used extensively here.  If your machine doesn't have strstr,
  1475.  * you need to do two things:
  1476.  *
  1477.  *   o uncomment the STRSTRF def in the Makefile to get a free version
  1478.  *   o beat up your vendor for not giving it to you
  1479.  *
  1480.  *  SunOS didn't have it until 4.1, for example
  1481.  *
  1482.  *
  1483.  * LoadPDS(fname, numcols)  -  coerces a PDS/VICAR image
  1484.  * WriteVICAR(fp, pic, w, h, r,g,b, numcols, style)
  1485.  */
  1486.  
  1487. /*
  1488.  * Copyright 1989, 1990 by Anthony A. Datri
  1489.  *
  1490.  * Permission to use, copy, and distribute for non-commercial purposes,
  1491.  * is hereby granted without fee, providing that the above copyright
  1492.  * notice appear in all copies and that both the copyright notice and this
  1493.  * permission notice appear in supporting documentation.
  1494.  *
  1495.  * This software is provided "as is" without any express or implied warranty.
  1496.  */
  1497.  
  1498.  
  1499. #include "xv.h"
  1500.  
  1501. #ifndef TRUE
  1502. #define TRUE (1)
  1503. #define FALSE (0)
  1504. #endif
  1505.  
  1506. #define PDSFIXED    (1)
  1507. #define    PDSVARIABLE    (2)
  1508. #define PDSTRASH    (-1)
  1509. #define VICAR        (3)
  1510. #define MAX_SIZE    20480 /*10240*/    /* a guess -- even magellan images aren't
  1511.                     bigger than 2k x 2k */
  1512. #define RTBUFFSIZE    20    /* small buffer for magic */
  1513. #define FNAMESIZE    1024    /* too hard to generalize really getting it */
  1514. #define PDSUNCOMP    "pdsuncomp" /* filter to un-Huffmanize */
  1515. /* This is arbitrary.  Everything I've seen so far fits */
  1516. #define COMMENTSIZE    50
  1517.  
  1518.  
  1519. static char    scanbuff[MAX_SIZE], rtbuff[RTBUFFSIZE], infobuff[COMMENTSIZE],
  1520.         spacecraft[COMMENTSIZE],
  1521.         target[COMMENTSIZE],
  1522.         filtname[COMMENTSIZE],
  1523.         mphase[COMMENTSIZE],
  1524.         iname[COMMENTSIZE],
  1525.         itime[COMMENTSIZE],
  1526.         pdsuncompfname[FNAMESIZE];
  1527. byte *image;
  1528.  
  1529.  
  1530. /* here's an strstr for the libc-impaired */
  1531.  
  1532. #ifdef NOSTRSTR
  1533. /* 
  1534.  * strstr.c --
  1535.  *
  1536.  *    Source code for the "strstr" library routine.
  1537.  *
  1538.  * Copyright 1988 Regents of the University of California
  1539.  * Permission to use, copy, modify, and distribute this
  1540.  * software and its documentation for any purpose and without
  1541.  * fee is hereby granted, provided that the above copyright
  1542.  * notice appear in all copies.  The University of California
  1543.  * makes no representations about the suitability of this
  1544.  * software for any purpose.  It is provided "as is" without
  1545.  * express or implied warranty.
  1546.  */
  1547.  
  1548. #ifndef lint
  1549. static char rcsid[] = "$Header: /sprite/src/lib/c/string/RCS/strstr.c,v
  1550. 1.2 89/03/22 16:07:57 rab Exp $ SPRITE (Berkeley)";
  1551. #endif /* not lint */
  1552.  
  1553. /*
  1554.  *----------------------------------------------------------------------
  1555.  *
  1556.  * strstr --
  1557.  *
  1558.  *    Locate the first instance of a substring in a string.
  1559.  *
  1560.  * Results:
  1561.  *    If string contains substring, the return value is the
  1562.  *    location of the first matching instance of substring
  1563.  *    in string.  If string doesn't contain substring, the
  1564.  *    return value is 0.  Matching is done on an exact
  1565.  *    character-for-character basis with no wildcards or special
  1566.  *    characters.
  1567.  *
  1568.  * Side effects:
  1569.  *    None.
  1570.  *
  1571.  *----------------------------------------------------------------------
  1572.  */
  1573.  
  1574. char *
  1575. strstr(string, substring)
  1576.     char *string;    /* String to search. */
  1577.     char *substring;        /* Substring to try to find in string. */
  1578. {
  1579.     register char *a, *b;
  1580.  
  1581.     /* First scan quickly through the two strings looking for a
  1582.      * single-character match.  When it's found, then compare the
  1583.      * rest of the substring.
  1584.      */
  1585.  
  1586.     b = substring;
  1587.     if (*b == 0) {
  1588.     return string;
  1589.     }
  1590.     for ( ; *string != 0; string += 1) {
  1591.     if (*string != *b) {
  1592.         continue;
  1593.     }
  1594.     a = string;
  1595.     while (1) {
  1596.         if (*b == 0) {
  1597.         return string;
  1598.         }
  1599.         if (*a++ != *b++) {
  1600.         break;
  1601.         }
  1602.     }
  1603.     b = substring;
  1604.     }
  1605.     return (char *) 0;
  1606. }
  1607. #endif /* NOSTRSTR */
  1608.  
  1609. /* get a NULL-, CR-, or CRLF-terminated record from a PDS file */
  1610. /* The method of termination is unpredictable.  A pox on VMS   */
  1611.  
  1612. int getpdsrec(f,buff)
  1613. FILE *f;
  1614. char *buff; {
  1615.  
  1616.     static char *bp;
  1617.     static int count;
  1618.  
  1619.     count=0;
  1620.     bp=buff;
  1621.     for (;TRUE;) {
  1622.     (*bp)=fgetc(f);
  1623.     switch (*bp) {
  1624.         case '\r':
  1625.         *bp='\0';
  1626.         switch ((*(bp+1))=fgetc(f)) {
  1627.             case EOF:
  1628.             case '\n':
  1629.             break;
  1630.             default:
  1631.             ungetc(*(bp+1),f);
  1632.             }
  1633.         return(count);
  1634.         case EOF:
  1635.         *bp='\0';
  1636.         return(count);            
  1637.         case '\0':
  1638.         return(count);
  1639.         default:
  1640.         count++;
  1641.         bp++;
  1642.       }
  1643.     }
  1644. }
  1645.  
  1646. /* A VICAR image seems to begin with a one-line header describing all sorts
  1647.  * of things, almost all of which don't mean much to Joe User, who just
  1648.  * wants to see what Venus looks like.  The first thing in this label is a
  1649.  * string defining the size of the label, like "LBLSIZE=2048".  Then there's
  1650.  * other crud of variable usefulness.  Important to us are the NL and NS
  1651.  * fields, which seem to tell us the number of columns and rows, respectively.
  1652.  * Among these other fields seem to be the local map coordinates of the region.
  1653.  * These files are easy -- you can even convert one to usefulness by grabbing
  1654.  * the dimensions and lblsize and feeding to rawtopgm.  For example, if
  1655. lblsize,
  1656.  * nl, and ns are 2048, 1536, and 2048, respectively, use "rawtopgm -headerskip
  1657.  * 2048 2048 1536 <foo.img >foo.pgm.  All of the samples I've seen are 8 bits
  1658.  * deep, so we assume that.  Yeah, yeah, that's nasty and evil, and I'm
  1659.  * terribly ashamed of it, but I'm not going to bother with bit fiddling
  1660.  * until I see an image that requires it
  1661.  *
  1662.  * These images are typically fairly big, so it makes sense to verify the
  1663.  * format before we try to read it all in.
  1664.  *
  1665.  * PDS images are prefixed like this:
  1666.  *
  1667.  *  od -a c2061139.imq | head -a
  1668.  *  0000000    - nul   N   J   P   L   1   I   0   0   P   D   S   1   0   0
  1669.  *
  1670.  * so we'll read off the first two chars, which seem to be a length field
  1671.  * of some kind, then look for NJPL..  But NOOOOOO, images on the Sampler
  1672.  * disc just HAVE to leave off the first two bytes.  Bloody HELL!  This
  1673.  * is the distinction between the fixed and variable-record files.
  1674.  */
  1675.             
  1676.  
  1677.  
  1678.  
  1679.  
  1680. /*******************************************/
  1681. int LoadPDS(fname,nc)
  1682.      char *fname;
  1683.      int   nc;    {
  1684.  
  1685. int tempnum;
  1686. FILE    *zf;
  1687. static int isfixed,teco,i,j,itype,lastwasinote,
  1688.     recsize,hrecsize,irecsize,isimage,labelrecs,labelsofar,
  1689.     x,y,lpsize,lssize,samplesize,returnp,labelsize,yy;
  1690. char    *tmp;
  1691.  
  1692. isfixed=TRUE;
  1693. returnp=isimage=FALSE;
  1694. itype=PDSTRASH;
  1695.  
  1696. teco=i=j=recsize=hrecsize=irecsize=labelrecs=x=y=lpsize=lssize=
  1697.         samplesize=labelsize=labelsofar=0;
  1698. (*pdsuncompfname)=(*iname)=(*target)=(*filtname)=(*itime)=(*spacecraft)=(*scanb
  1699. uff)=
  1700.         (*mphase)=(*rtbuff)='\0';
  1701.  
  1702. /* there may be some wisdom in statically mallocing space for an 800x800
  1703.    image, since that's what the Voyager cd's have, or even a 2kx2k, since
  1704.    some of the Magellan images from ames are that size */
  1705.  
  1706.  
  1707. zf=fopen(fname,"r");
  1708. if (!zf) {
  1709.     SetISTR(ISTR_INFO,"LoadPDS: can't open %s\n",fname);
  1710.     return(1);
  1711. }
  1712.  
  1713. /* read the magic.  If it's got two bytes of crud in front of it, it's
  1714.    a damned "variable-length-record" file, and we have to jump through
  1715.    bloody VAX hoops, and feed it through pdsuncomp to get useful bits */
  1716.  
  1717. if ((teco=fread(rtbuff,13,1,zf)) != 1) {
  1718.    SetISTR(ISTR_INFO,"LoadPDS: couldn't read magic: %d,%s",teco,fname);
  1719.    Warning();
  1720.    fclose(zf);
  1721.    return(1);
  1722. }
  1723.  
  1724. rtbuff[13]='\0';    /* this makes sscanf so much happier */
  1725.  
  1726. if ((strncmp(rtbuff, "NJPL1I00PDS",11) == 0) ||
  1727.     ((isfixed=strncmp(rtbuff+2,"NJPL1I00PDS",11)) == 0)) {
  1728.  
  1729.     /* we only handle 8 b/p right now */
  1730.     SetISTR(ISTR_FORMAT, isfixed ? "PDS/VICAR, 8 bits per pixel." :
  1731.                     "Huffman-encoded PDS, 8 bits per pixel.");
  1732.  
  1733.     if (!(isfixed)) {
  1734.     teco = ((*rtbuff) + ((*(rtbuff+1)) << 8));
  1735.     fread(rtbuff,(teco % 2 ? teco + 1 : teco ) - 11,1,zf);
  1736.     }
  1737.  
  1738.  
  1739.     /* we know that we've got a PDS file of some sort.    We have to
  1740.        search through the labels looking for things because usage doesn't seem
  1741.        to be consistent, or even predictable.  When I added this format to
  1742.        xloadimage, I had the code spew out various peices of information, like
  1743.        the name of the target, filter used, etc.  Xv, however, doesn't really
  1744.        provide precedent for this kind of thing, and I can't really stick it
  1745.        into the info box without overhauling it.  Maybe later I'll add a
  1746.        -verbose switch which this module will interpret as license to scribble
  1747.        on stdout or stderr */
  1748.  
  1749.     for (;;) {
  1750.     if (isfixed) {
  1751.         if (getpdsrec(zf,scanbuff) == 0) {
  1752.         SetISTR(ISTR_INFO,
  1753.             "corrupt or incomplete PDS labels (low fread)");
  1754.         Warning();
  1755.         break;
  1756.         }
  1757.     } else {
  1758.         /* AAAARGGGGH!  We've got a bloody variable-length file where
  1759.          * the headers are preceded by a byte count, as a VAX 16-bit
  1760.          * integer of all things.  VMS:  Just Say NFW.
  1761.          * "A compressed image file is composed of variable-length records
  1762.          * defined according to the ISO standard.  Each variable length
  1763.          * record starts with a record length indicator, stored as a 16-bit
  1764.          * integer, followed by the number of bytes indicated in the record
  1765.          * length indicator. If the length indicator is odd, then a pad byte
  1766.          * is appended to the end of the record so that all records contain
  1767.          * an even number of bytes."*/
  1768.                                                                         
  1769.  
  1770.         i=getc(zf);
  1771.         j=getc(zf);
  1772.         if (j == EOF) {
  1773.         SetISTR(ISTR_INFO,"LoadPDS: j is EOF\n");
  1774.         fclose(zf);
  1775.         return(1);
  1776.         }
  1777.         teco = i + (j << 8);
  1778.         if (teco % 2) {
  1779.         teco++;
  1780.         }
  1781.         if (fread(scanbuff,teco,1,zf) != 1) {
  1782.         SetISTR(ISTR_INFO,"LoadPDS: bad fread reading labels\n");
  1783.         fclose(zf);
  1784.         return(1);
  1785.         }
  1786.         scanbuff[teco]='\0';
  1787.     }
  1788.  
  1789.     /* otay, we've managed to wrestle a header of some sort from the
  1790.        file -- now we grep through until we hit the END, at which point
  1791.        we break out of the loop and see what we've got.  In the future,
  1792.        we'll check for informational headers and write them out if the
  1793.        fool user wants them.  There seems to be disagreement about what
  1794.        the headers are called, since we might find, for example, either
  1795.        TARGET_BODY or TARGET_NAME.    Bloody 'ell. */
  1796.  
  1797.     if (strcmp(scanbuff,"END") == 0) {
  1798.         break;
  1799.     } else if (sscanf(scanbuff,"RECORD_TYPE = %s",rtbuff) == 1) {
  1800.         if (strncmp(rtbuff,"VARIABLE_LENGTH",15) == 0) {
  1801.         itype=PDSVARIABLE;
  1802.         } else if (strncmp(rtbuff,"FIXED_LENGTH",12) == 0) {
  1803.         itype=PDSFIXED;
  1804.         } else {
  1805.         rtbuff[RTBUFFSIZE-1]='\0'; /* juuuust in case */
  1806.         SetISTR(ISTR_INFO,
  1807.             "LoadPDS: unsupported record type \"%s\"\n",rtbuff);
  1808.         fclose(zf);
  1809.         return(1);
  1810.         }
  1811.     } else if (sscanf(scanbuff,"RECORD_BYTES = %d",&recsize) == 1) {
  1812.         /* these default to RECORD_BYTES unless explicitly set */
  1813.         if (hrecsize == 0)
  1814.         hrecsize=recsize;
  1815.         if (irecsize == 0)
  1816.         irecsize=recsize;
  1817.         continue;
  1818.        } else if (sscanf(scanbuff,"FILE_TYPE = %s", rtbuff) != NULL) {
  1819.         if (strncmp(rtbuff,"IMAGE",5) == 0) {
  1820.         isimage=TRUE;
  1821.         continue;
  1822.         } else {
  1823.         isimage=FALSE;
  1824.         break;
  1825.         }
  1826.     } else if ((sscanf(scanbuff," HEADER_RECORDS = %d",&labelrecs) == 1) ||
  1827.            (sscanf(scanbuff," LABEL_RECORDS = %d", &labelrecs) == 1)) {
  1828.         continue;
  1829.     } else if (sscanf(scanbuff," IMAGE_LINES = %d",&y) == 1) {
  1830.          isimage=TRUE; continue;
  1831.     } else if (sscanf(scanbuff," LINE_SAMPLES = %d",&x) == 1) {
  1832.          continue;
  1833.     } else if (sscanf(scanbuff," LINES = %d",&y) == 1) {
  1834.          isimage=TRUE; continue;
  1835.     } else if (sscanf(scanbuff," HEADER_RECORD_BYTES = %d",&hrecsize)==1) {
  1836.          continue;
  1837.     } else if (sscanf(scanbuff," IMAGE_RECORD_BYTES = %d",&irecsize)==1) {
  1838.          continue;
  1839.     } else if (sscanf(scanbuff," LINE_PREFIX_BYTES = %d",&lpsize)==1) {
  1840.          continue;
  1841.     } else if (sscanf(scanbuff," LINE_SUFFIX_BYTES = %d",&lssize)==1) {
  1842.          continue;
  1843.     } else if (sscanf(scanbuff," SAMPLE_BITS = %d", &samplesize) == 1) {
  1844.          continue;
  1845.     } else if (sscanf(scanbuff," SPACECRAFT_NAME = %s", spacecraft) == 1) {
  1846.          continue;
  1847. /*    } else if (sscanf(scanbuff," MISSION_PHASE_NAME = %s", mphase) == 1) {
  1848.          continue;
  1849.     } else if (sscanf(scanbuff," MISSION_PHASE = %s", mphase) == 1) {
  1850.          continue;*/
  1851.     } else if (sscanf(scanbuff," TARGET_NAME = %s", target) == 1) {
  1852.          continue;
  1853.     } else if (sscanf(scanbuff," TARGET_BODY = %s", target) == 1) {
  1854.          continue;
  1855. /*    } else if (sscanf(scanbuff," INSTRUMENT_NAME = %s", iname) == 1) {
  1856.          continue;*/
  1857.     } else if (sscanf(scanbuff," SPACECRAFT_EVENT_TIME = %s", itime) == 1) {
  1858.          continue;
  1859.     } else if (sscanf(scanbuff," IMAGE_TIME = %s", itime) == 1) {
  1860.          continue;
  1861.     } else if (sscanf(scanbuff," FILTER_NAME = %s", filtname) == 1) {
  1862.          continue;
  1863.     } else if (sscanf(scanbuff," INSTRUMENT_FILTER_NAME = %s", filtname) == 1) {
  1864.          continue;
  1865.     }
  1866. /* I never did understand any of these
  1867.     } else if (sscanf(scanbuff," GAIN_MODE_ID = %s", gainmode) == 1) {
  1868.          continue;
  1869.     } else if (sscanf(scanbuff," INSTRUMENT_GAIN_STATE = %s", gainmode) == 1) {
  1870.          continue;
  1871.     } else if (sscanf(scanbuff," EDIT_MODE_ID = %s", editmode) == 1) {
  1872.          continue;
  1873.     } else if (sscanf(scanbuff," INSTRUMENT_EDIT_MODE = %s", editmode) == 1) {
  1874.          continue;
  1875.     } else if (sscanf(scanbuff," SCAN_MODE_ID = %s", scanmode) == 1) {
  1876.          continue;
  1877.     } else if (sscanf(scanbuff," INSTRUMENT_SCAN_RATE = %s", scanmode) == 1) {
  1878.          continue;
  1879.     } else if (sscanf(scanbuff," SHUTTER_MODE_ID = %s", shutmode) == 1) {
  1880.          continue;
  1881.     } else if (sscanf(scanbuff," INSTRUMENT_SHUTTER_MODE = %s", shutmode) == 1) {
  1882.          continue; */
  1883.     }
  1884.  
  1885.     if ((isimage == TRUE) && (labelsize=(labelrecs * hrecsize))) {
  1886.     if (samplesize!= 8) {
  1887.         SetISTR(ISTR_INFO,"This image looks to be %d bits deep, but I can
  1888. only handle 8-bit PDS files\n");
  1889.         fclose(zf);
  1890.         return(1);
  1891.     }
  1892.     } else {
  1893.     SetISTR(ISTR_INFO,"This looks a lot like a PDS/VICAR image, but I can't
  1894. see the size of the label\n");
  1895.     fclose(zf);
  1896.     return(1);
  1897.     }
  1898. /* Some day this should be generalized to read <>8-bit files.  If I ever find
  1899.  * one that's interesting, I'll do the work. */
  1900.  
  1901. } else if (sscanf(rtbuff,"LBLSIZE = %d%n",&labelsize,&labelsofar) == 1) {
  1902.     /* we've got a VICAR file.  Let's find out how big the puppy is */
  1903.     itype=VICAR;
  1904.     if (fread(scanbuff,labelsize-labelsofar,1,zf) == 1) {
  1905.         if ((tmp=strstr(scanbuff,"NL=")) == NULL) {
  1906.         SetISTR(ISTR_INFO,"LoadPDS: bad NL in VICAR\n");
  1907.         returnp=TRUE;
  1908.         }
  1909.         if (sscanf(tmp,"NL = %d",&y) != 1) {
  1910.         SetISTR(ISTR_INFO,"LoadPDS: bad scan NL in VICAR\n");
  1911.         returnp=TRUE;
  1912.         }
  1913.         if ((tmp=strstr(scanbuff, "NS=")) == NULL) {
  1914.         SetISTR(ISTR_INFO,"LoadPDS: bad NS in VICAR\n");
  1915.         returnp=TRUE;
  1916.         }
  1917.         if (sscanf(tmp, "NS = %d",&x) != 1) {
  1918.         SetISTR(ISTR_INFO,"LoadPDS: bad scan NS in VICAR\n");
  1919.         returnp=TRUE;
  1920.         }
  1921.     }
  1922. } else {
  1923.     SetISTR(ISTR_INFO,"LoadPDS: I guess this isn't one of mine after all\n");
  1924.     returnp=TRUE;
  1925. }
  1926.  
  1927. if (returnp) {
  1928.     fclose(zf);
  1929.     return(1);
  1930. }
  1931.  
  1932. /* PDS files tend to have lots of information like this in them.  The
  1933.  * following are a few of the more interesting headers.  We'd do more, but
  1934.  * there's only so much space in the info box */
  1935.  
  1936. *infobuff='\0';
  1937. if (*spacecraft) {
  1938.     strcat(infobuff,spacecraft);
  1939. }
  1940. if (*target) {
  1941.     strcat(infobuff,", ");
  1942.     strcat(infobuff,target);
  1943. }
  1944. if (*filtname) {
  1945.     strcat(infobuff,", ");
  1946.     strcat(infobuff,filtname);
  1947. }
  1948. if (*itime) {
  1949.     strcat(infobuff,", ");
  1950.     strcat(infobuff,itime);
  1951. }
  1952. SetISTR(ISTR_WARNING,infobuff);
  1953.  
  1954. strcpy(pdsuncompfname,fname);
  1955. switch (itype) {
  1956.     case VICAR:
  1957.     SetISTR(ISTR_FORMAT, "VICAR, 8 bits per pixel.");
  1958.     rewind(zf);
  1959.     break;
  1960.     case PDSFIXED:
  1961.     SetISTR(ISTR_FORMAT, "PDS, 8 bits per pixel.");
  1962.     rewind(zf);
  1963.     break;
  1964.     case PDSVARIABLE:
  1965.     SetISTR(ISTR_FORMAT, "PDS, 8 bits per pixel, Huffman-encoded.");
  1966.     fclose(zf);
  1967. /*    strcat(fname,".out");*/
  1968.     strcpy(pdsuncompfname,"/tmp/xvhuffXXXXXX");
  1969.     mktemp(pdsuncompfname);
  1970.     sprintf(scanbuff,"%s %s - 4 >%s",PDSUNCOMP,fname,pdsuncompfname);
  1971.     SetISTR(ISTR_INFO,"De-Huffmanizing '%s'...",fname);
  1972.     /* pdsuncomp filters to a raw file */
  1973.     if (tempnum=system(scanbuff)) {
  1974.         SetISTR(ISTR_INFO,"Unable to de-Huffmanize '%s'.",fname);
  1975. /*fprintf(stderr,"system returned %d\n",tempnum);fflush(stderr);*/
  1976.         Warning();
  1977.         return(1);
  1978.     }
  1979. fprintf(stderr,"system returned %d\n",tempnum);fflush(stderr);
  1980.     zf=fopen(pdsuncompfname,"r");
  1981.     if (!zf) {
  1982.         SetISTR(ISTR_INFO,"LoadPDS: can't open uncompressed file %s\n",
  1983.                       pdsuncompfname);
  1984.         Warning();
  1985.         return(1);
  1986.     }
  1987.     }
  1988.  
  1989. /* skip headers */
  1990.  
  1991. if (itype != PDSVARIABLE) {
  1992.     fread(scanbuff,labelsize,1,zf);
  1993. }
  1994.  
  1995. image=(byte *)malloc(x*y);
  1996. if (image == NULL) {
  1997.     SetISTR(ISTR_INFO,"LoadPDS: couldn't malloc %d",x*y);
  1998.     Warning();
  1999.     fclose(zf);
  2000.     if (itype==PDSVARIABLE)
  2001.     unlink(pdsuncompfname);
  2002.     exit(1);
  2003. }
  2004.  
  2005. if ((lssize || lpsize) & (itype == PDSFIXED)) {
  2006.     /* ARrrrgh.  Some of these images have crud intermixed with the image, */
  2007.     /* preventing us from freading in one fell swoop (whatever a fell
  2008. swoop is */
  2009.     for (yy=0;yy<y;yy++) {
  2010.     if (lpsize && ((teco=(fread(scanbuff,lpsize,1,zf))) != 1)) {
  2011.         SetISTR(ISTR_INFO, "LoadPDS: unexpected EOF reading prefix");
  2012.         Warning();
  2013.         fclose(zf);
  2014.         return(1);
  2015.     }
  2016.     if ((teco=(fread(image+(yy*x),x,1,zf))) != 1) {
  2017.         SetISTR(ISTR_INFO, "LoadPDS: unexpected EOF reading line %d",yy);
  2018.         Warning();
  2019.         fclose(zf);
  2020.         return(1);
  2021.     }
  2022.     if (lssize && ((teco=(fread(scanbuff,lssize,1,zf))) != 1)) {
  2023.         SetISTR(ISTR_INFO, "LoadPDS: unexpected EOF reading suffix");
  2024.         Warning();
  2025.         fclose(zf);
  2026.         return(1);
  2027.     }
  2028.     }
  2029. } else if ((yy=fread(image,x*y,1,zf)) != 1) {
  2030.     SetISTR(ISTR_INFO,"LoadPDS: error reading image data");
  2031.     Warning();
  2032.     fclose(zf);
  2033.     if (itype==PDSVARIABLE)
  2034.             unlink(pdsuncompfname);
  2035.     return(1);
  2036.  
  2037. }
  2038. /*SetISTR(ISTR_INFO,infobuff);*/
  2039. fclose(zf);
  2040. if (itype==PDSVARIABLE)
  2041.     unlink(pdsuncompfname);
  2042.  
  2043. /* fix up xv globals */
  2044.  
  2045. pic = image;
  2046. pWIDE = x;
  2047. pHIGH = y;
  2048.  
  2049. /* these are grayscale, so cobble up a ramped colormap */
  2050.  
  2051. for (yy=0; yy<=255; yy++) {
  2052. /*    *(r+yy)=*(g+yy)=*(b+yy)=yy;*/
  2053.     *(r+yy)=yy;
  2054. }
  2055. /* this is cheating, but saves a few hundred ops */
  2056. memcpy(g,r,256*(sizeof(byte)));
  2057. memcpy(b,r,256*(sizeof(byte)));
  2058.  
  2059. return(0);
  2060. }
  2061. @//E*O*F xvpds.c//
  2062. chmod u=rw,g=r,o=r xvpds.c
  2063.  
  2064. exit 0
  2065. (Message /usr/users/bradley/Mail/inbox:15)
  2066. Return-Path: beser@aplcomm.jhuapl.edu
  2067. Received-Date: Wed, 13 Nov 91 16:52:37 EST
  2068. Received: from aplcomm.jhuapl.edu by central.cis.upenn.edu
  2069.     id AA16950; Wed, 13 Nov 91 16:52:35 -0500
  2070. Posted-Date: Wed, 13 Nov 91 16:52:51 -0500
  2071. Received: by aplcomm.jhuapl.edu (5.61/4.7)
  2072.     id AA25505; Wed, 13 Nov 91 16:52:51 -0500
  2073. Date: Wed, 13 Nov 91 16:52:51 -0500
  2074. From: beser@aplcomm.jhuapl.edu (Nick Beser)
  2075. Message-Id: <9111132152.AA25505@aplcomm.jhuapl.edu>
  2076. To: bradley@central.cis.upenn.edu
  2077.  
  2078. John,
  2079.     I wanted to let you know that I have found a problem with the vicar
  2080. patches that I told you about several weeks ago. I have been attempting to
  2081. read the Viking orbiter images with the modified xv program and have discovered
  2082. a difference in the header information between different PDS formatted images.
  2083. The voyager images have a header that looks like the following:
  2084.  
  2085. uvisiss{beser}45: od -a c1072726.imq | more
  2086. 0000000    - nul   N   J   P   L   1   I   0   0   P   D   S   1   0   0
  2087. 0000020    0   0   0   0   0   0  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp
  2088. 0000040   sp  sp  sp   =  sp   S   F   D   U   _   L   A   B   E   L nul
  2089. 0000060    " nul   /   *  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp   F   I
  2090. 0000100    L   E  sp   F   O   R   M   A   T  sp   A   N   D  sp   L   E
  2091. 0000120    N   G   T   H   2 nul   R   E   C   O   R   D   _   T   Y   P
  2092. 0000140    E  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp
  2093. 0000160   sp  sp  sp  sp  sp  sp  sp   =  sp   V   A   R   I   A   B   L
  2094. 0000200    E   _   L   E   N   G   T   H   & nul   R   E   C   O   R   D
  2095. 0000220    _   B   Y   T   E   S  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp
  2096. 0000240   sp  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp   =  sp   8   3   6
  2097.  
  2098. The Viking Images have a header that looks like:
  2099.  
  2100. uvisiss{beser}50: od -a f139s01.imq | more
  2101. 0000000    5 nul   C   C   S   D   3   Z   F   0   0   0   0   1   0   0
  2102. 0000020    0   0   0   0   0   1   N   J   P   L   3   I   F   0   P   D
  2103. 0000040    S   2   0   0   0   0   0   0   0   1  sp   =  sp   S   F   D
  2104. 0000060    U   _   L   A   B   E   L nul   % nul   /   *  sp  sp  sp  sp
  2105. 0000100   sp  sp  sp  sp  sp  sp   F   I   L   E  sp   F   O   R   M   A
  2106. 0000120    T  sp   A   N   D  sp   L   E   N   G   T   H  sp   *   / nul
  2107. 0000140    2 nul   R   E   C   O   R   D   _   T   Y   P   E  sp  sp  sp
  2108. 0000160   sp  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp
  2109. 0000200   sp  sp  sp   =  sp   V   A   R   I   A   B   L   E   _   L   E
  2110. 0000220    N   G   T   H   ' nul   R   E   C   O   R   D   _   B   Y   T
  2111. 0000240    E   S  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp  sp
  2112.  
  2113. The program has two subroutines that parse the header of the PDS files,
  2114. and if it matches the NJPLxx code (in the first 12 bytes of the header,
  2115. it calls it a PDS file. It seems that the program should look at more
  2116. of the header. The two routines are xv.c and xvpds.c. If you are going
  2117. to release a new version of the program I could send you some sample images 
  2118. from Voyager, Magellan, and Viking so you could confirm that they can be
  2119. read. Will you be releasing the code soon? Are you looking for beta testers?
  2120. Please let me know as soon as the code is available.
  2121.  
  2122. Nick Beser
  2123. beser@aplcomm.jhuapl.edu
  2124.  
  2125. (Message /usr/users/bradley/Mail/inbox:13)
  2126. Return-Path: datri@lovecraft.convex.com
  2127. Received-Date: Fri, 22 Nov 91 10:06:05 EST
  2128. Received: from convex.convex.com by central.cis.upenn.edu
  2129.     id AA13501; Fri, 22 Nov 91 10:06:02 -0500
  2130. Posted-Date: Fri, 22 Nov 1991 09:05:46 -0600 (CST)
  2131. Received: from lovecraft.convex.com by convex.convex.com (5.61/1.35)
  2132.     id AA27919; Fri, 22 Nov 91 09:05:50 -0600
  2133. Received: by lovecraft.convex.com (4.1/SMI-4.1)
  2134.     id AA09791; Fri, 22 Nov 91 09:05:48 CST
  2135. Received: from Messages.7.15.N.CUILIB.3.45.SNAP.NOT.LINKED.lovecraft.convex.com.sun4.41
  2136.           via MS.5.6.lovecraft.convex.com.sun4_41;
  2137.           Fri, 22 Nov 1991 09:05:46 -0600 (CST)
  2138. Message-Id: <Ad=Fn_G2e4NhIZT1AT@concave>
  2139. Date: Fri, 22 Nov 1991 09:05:46 -0600 (CST)
  2140. From: "Anthony A. Datri" <datri@concave.convex.com>
  2141. To: bradley@central.cis.upenn.edu
  2142. Subject: new xv module
  2143.  
  2144. I've updated my PDS/VICAR support for xv to handle the format variant
  2145. found on the Viking CD-ROMs.  This includes a new, more general
  2146. decompression program called vdcomp.  There's a tar file of patches on
  2147. convex.com in pub.
  2148.